home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / c / stut_src / s_malloc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-27  |  7.0 KB  |  329 lines
  1. /*
  2.  * Special MALLOC library
  3.  * Copyright (c)1995 by Fran‡ois PLANQUE
  4.  *
  5.  * BibliothŠque de fonctions destin‚e … d‚bugguer les
  6.  * erreur de gestion m‚moire avec malloc(), calloc(), free()et strdup()
  7.  * 
  8.  * ATTENTION: Ce module fait des affichages texte sur stdout. (des printf() quoi!)
  9.  *
  10.  * TABS: L'indentation est pr‚vue pour des tabulations de taille 3.
  11.  *
  12.  * 10.07.95: fplanque: Created
  13.  */
  14.  
  15. /*
  16.  * Headers standard:
  17.  */
  18.     #include <stdio.h>
  19.     #include <stdlib.h>
  20.     #include <string.h>
  21.  
  22.  
  23. /*
  24.  * ---------------------------- VARIABLES -------------------------------
  25.  */
  26.  
  27. /*
  28.  * Variables globales PRIVEES
  29.  */
  30.     long    M_lnb_mallocs = 0;
  31.  
  32.  
  33. /*
  34.  * ---------------------------- FONCTIONS -------------------------------
  35.  */
  36.  
  37. /*
  38.  * S_Check(-)
  39.  *
  40.  * V‚rifie l'int‚grit‚ d'une zone m‚moire allou‚e par cette librairie
  41.  * Accessoirement: renvoie l'adresse r‚elle du malloc avec ses informations
  42.  * de contr“le.
  43.  * Pr‚vue … priori pourun usage interne, mais peut ˆtre mis … profit 
  44.  * pour v‚rifier periodiquement l'int‚grit‚ d'une zone...
  45.  *
  46.  * 10.07.95: fplanque: Created
  47.  * 27.07.95: fplanque: Chang‚ noms de variables
  48.  */
  49. void * S_Check(                /* Out: adresse de la zone avec head & foot */
  50.             void * p_manip )    /* In:  adresse de manipulation */
  51. {
  52.     char * pc_real = (char*)p_manip - ( 4 + sizeof(size_t) );
  53.     size_t size;
  54.  
  55.     if(    pc_real[ 0 ] != 'd'
  56.         || pc_real[ 1 ] != 'e'
  57.         || pc_real[ 2 ] != 'b'
  58.         || pc_real[ 3 ] != 'u' )
  59.     {
  60.         printf( "\nERREUR: Zone corrompue au debut!" );
  61.         getchar();
  62.         return NULL;
  63.     }
  64.             
  65.     size = *( (size_t *)(pc_real+4) );        /* Pas g‚gen */
  66.     
  67.     if(    pc_real[ size-4 ] != 'f'
  68.         || pc_real[ size-3 ] != 'i'
  69.         || pc_real[ size-2 ] != 'n'
  70.         || pc_real[ size-1 ] != '!' )
  71.     {
  72.         printf( "\nERREUR: Zone corrompue … la fin!" );
  73.         getchar();
  74.         return NULL;
  75.     }
  76.     
  77.     return (void *) pc_real;
  78. }
  79.  
  80.  
  81. /*
  82.  * S_malloc(-)
  83.  *
  84.  * Remplace malloc() et alloue des petits tampons de securit‚
  85.  * de part et d'autre du bloc pour d‚tecter les d‚bordements
  86.  * lors de S_free()
  87.  *
  88.  * 10.07.95: fplanque: Created
  89.  * 27.07.95: fplanque: Chang‚ noms de variables
  90.  */
  91. void * S_malloc(             /* Out: Ptr sur la zone allou‚e (comme avec malloc()) */
  92.             size_t size )    /* In:  taille dela zone … allouer */
  93. {
  94.     char * pc_real;
  95.     void * p_manip;
  96.  
  97.     size += 8 + sizeof( size_t );
  98.  
  99.     pc_real = malloc( size );
  100.     if( pc_real == NULL )
  101.     {    /*
  102.          * Il peut ˆtre n‚cessaire d'enlever ce Warning si votre programme
  103.          * effectue et gŠre correctement des mallocs de grande taille par
  104.          * rapport … la m‚moire disponible.
  105.          */
  106.         printf( "\nWARNING: Malloc a ‚chou‚!" );
  107.     }
  108.     M_lnb_mallocs ++;
  109.     
  110.     pc_real[0] = 'd';
  111.     pc_real[1] = 'e';
  112.     pc_real[2] = 'b';
  113.     pc_real[3] = 'u';
  114.     
  115.     /*    
  116.      * Sauve la taille de la zone alou‚e:
  117.      */
  118.     *( (size_t *)(pc_real+4) ) = size;
  119.     
  120.     pc_real[ size-4 ] = 'f';
  121.     pc_real[ size-3 ] = 'i';
  122.     pc_real[ size-2 ] = 'n';
  123.     pc_real[ size-1 ] = '!';
  124.  
  125.  
  126.     /*
  127.      * D‚termine l'adresse de manipulation.
  128.      * (Celle du d"but de la zone utilisateur)
  129.      * Pour faire comme si on avait fait un malloc standard
  130.      */
  131.     p_manip = pc_real + 4 + sizeof(size_t);
  132.     
  133.     /*
  134.      * V‚rifie l'int‚grit‚
  135.      */
  136.     S_Check( p_manip );
  137.  
  138.     return    p_manip;
  139. }
  140.  
  141.  
  142. /*
  143.  * S_strdup(-)
  144.  *
  145.  * Remplace strdup() et alloue des petits tampons de securit‚
  146.  * de part et d'autre de la chaine dupliqu‚e pour d‚tecter les d‚bordements
  147.  * lors de S_free()
  148.  *
  149.  * 10.07.95: fplanque: Created
  150.  * 27.07.95: fplanque: Chang‚ noms de variables
  151.  */
  152. char * S_strdup(                         /* Out: Ptr sur copie de la chaŒne */
  153.             const char * cpsz_src )    /* In:  Ptr sur la chaŒne … dupliquer */
  154. {
  155.     char * pc_real;
  156.     char * psz_dest;
  157.  
  158.     size_t size = strlen( cpsz_src ) + 1    /* Pour le \0 final */
  159.                          + 8 + sizeof( size_t );
  160.  
  161.     pc_real = malloc( size );
  162.     if( pc_real == NULL )
  163.     {
  164.         printf( "\nWARNING: Malloc dans Strdup impossible!" );
  165.     }
  166.     M_lnb_mallocs ++;
  167.     
  168.     pc_real[0] = 'd';
  169.     pc_real[1] = 'e';
  170.     pc_real[2] = 'b';
  171.     pc_real[3] = 'u';
  172.     
  173.     *( (size_t *)(pc_real+4) ) = size;
  174.     
  175.     pc_real[ size-4 ] = 'f';
  176.     pc_real[ size-3 ] = 'i';
  177.     pc_real[ size-2 ] = 'n';
  178.     pc_real[ size-1 ] = '!';
  179.     
  180.     /*
  181.      * Copie la chaine:
  182.      */
  183.     psz_dest = pc_real + 4 + sizeof(size_t);
  184.     strcpy( psz_dest, cpsz_src );
  185.     
  186.     /*
  187.      * V‚rifie l'int‚grit‚
  188.      */
  189.     S_Check( psz_dest );
  190.  
  191.     return psz_dest;
  192. }
  193.  
  194.  
  195. /*
  196.  * S_realloc(-)
  197.  *
  198.  * Remplace realloc() et alloue des petits tampons de securit‚
  199.  * de part et d'autre du bloc pour d‚tecter les d‚bordements
  200.  * lors de S_free()
  201.  *
  202.  * 10.07.95: fplanque: Created
  203.  * 27.07.95: fplanque: Il manquait un return NULL en cas de realloc impossible
  204.  * 27.07.95: fplanque: Chang‚ noms de variables
  205.  */
  206. void * S_realloc(             /* Out: Ptr sur la nouvelle zone allou‚e */
  207.             void * p_manip,     /* In:  Ptr sur une zone allou‚e */
  208.             size_t size )        /* In:  Nouvelle taille d‚sir‚e pour cette zone */
  209. {
  210.     char * pc_real;
  211.     
  212.     if( p_manip == NULL )
  213.     {    
  214.         printf( "\nWARNING: Trying to realloc() a NULL pointer!" );
  215.         getchar();
  216.         return NULL;
  217.     }
  218.  
  219.     /*
  220.      * V‚rifie l'int‚grit‚:
  221.      */
  222.     pc_real = S_Check( p_manip );
  223.     if( pc_real == NULL )
  224.     {
  225.         printf( "\nREALLOC() impossible!" );
  226.         return NULL;    
  227.     }
  228.  
  229.     size += 8 + sizeof( size_t );
  230.  
  231.     pc_real = realloc( pc_real, size );
  232.     if( pc_real == NULL )
  233.     {
  234.         printf( "\nWARNING: realloc impossible!" );
  235.         return NULL;
  236.     }
  237.     
  238.     /*
  239.      * Note: Ici, on ne re‚crit pas 'd' 'e' 'b' 'u' en d‚but de zone
  240.      * parce que le realloc … th‚oriquement conserv‚ l'ancien.
  241.      */
  242.     
  243.     *( (size_t *)(pc_real+4) ) = size;
  244.     
  245.     pc_real[ size-4 ] = 'f';
  246.     pc_real[ size-3 ] = 'i';
  247.     pc_real[ size-2 ] = 'n';
  248.     pc_real[ size-1 ] = '!';
  249.     
  250.     /*
  251.      * V‚rifie l'int‚grit‚
  252.      */
  253.     p_manip = pc_real + 4 + sizeof(size_t); 
  254.     S_Check( p_manip );
  255.     
  256.     return    p_manip;
  257. }
  258.  
  259.  
  260. /*
  261.  * S_free(-)
  262.  *
  263.  * Remplace free() pour les zones allou‚es avec S_malloc()
  264.  * v‚rifie l'int‚grit‚ des buffers de contr“le.
  265.  *
  266.  * 10.07.95: fplanque: Created
  267.  * 27.07.95: fplanque: Chang‚ noms de variables
  268.  */
  269. void S_free( void * p_manip )    /* In: Ptr sur une zone m‚moire allou‚e */
  270. {
  271.     char    *    pc_real;
  272.     size_t    size;
  273.     
  274.     if( p_manip == NULL )
  275.     {    
  276.         printf( "\nWARNING: On essaye de lib‚rer un pointeur NULL avec free()!" );
  277.         getchar();
  278.         return;
  279.     }
  280.  
  281.     /*
  282.      * V‚rifie l'int‚grit‚:
  283.      */
  284.     pc_real = S_Check( p_manip );
  285.     if( pc_real == NULL )
  286.     {
  287.         printf( "\nFREE() impossible!" );
  288.         return;
  289.     }
  290.  
  291.     /*
  292.      * marque la zone comme invalide
  293.      * (permettra par exemple de d‚tecter un double-free)
  294.      */
  295.     pc_real[0] = 'l';    /* "libre" */
  296.     pc_real[1] = 'i';
  297.     pc_real[2] = 'b';
  298.     pc_real[3] = 'r';
  299.     
  300.     size = *( (size_t *)(pc_real+4) );
  301.     
  302.     pc_real[ size-4 ] = 'o';    /* "obsolŠte" */
  303.     pc_real[ size-3 ] = 'b';
  304.     pc_real[ size-2 ] = 's';
  305.     pc_real[ size-1 ] = 'o';
  306.     
  307.     /*
  308.      * Lib‚ration effective:
  309.      */    
  310.     free( pc_real );
  311.     M_lnb_mallocs --;
  312. }
  313.  
  314.  
  315. /*
  316.  * S_MemStat(-)
  317.  * 
  318.  * Statistiques sur l'utilisation de la m‚moire.
  319.  * A appeler en fin de programme, par exemple.
  320.  *
  321.  * 10.07.95: fplanque: created
  322.  */
  323. void S_MemStat( void )
  324. {
  325.     printf( "\nMemory Usage Statistics:" );
  326.     printf( "\nMallocs remaining: %lu ", M_lnb_mallocs );
  327. }
  328.  
  329.